home *** CD-ROM | disk | FTP | other *** search
/ Personal Computer World 2009 February / PCWFEB09.iso / Software / Resources / Chat & Communication / Digsby build 37 / digsby_setup.exe / lib / distutils / cmd.pyo (.txt) < prev    next >
Encoding:
Python Compiled Bytecode  |  2008-10-13  |  9.9 KB  |  269 lines
  1. # Source Generated with Decompyle++
  2. # File: in.pyo (Python 2.5)
  3.  
  4. __revision__ = '$Id: cmd.py 37828 2004-11-10 22:23:15Z loewis $'
  5. import sys
  6. import os
  7. import string
  8. import re
  9. from types import *
  10. from distutils.errors import *
  11. from distutils import util, dir_util, file_util, archive_util, dep_util
  12. from distutils import log
  13.  
  14. class Command:
  15.     sub_commands = []
  16.     
  17.     def __init__(self, dist):
  18.         Distribution = Distribution
  19.         import distutils.dist
  20.         if not isinstance(dist, Distribution):
  21.             raise TypeError, 'dist must be a Distribution instance'
  22.         
  23.         if self.__class__ is Command:
  24.             raise RuntimeError, 'Command is an abstract class'
  25.         
  26.         self.distribution = dist
  27.         self.initialize_options()
  28.         self._dry_run = None
  29.         self.verbose = dist.verbose
  30.         self.force = None
  31.         self.help = 0
  32.         self.finalized = 0
  33.  
  34.     
  35.     def __getattr__(self, attr):
  36.         if attr == 'dry_run':
  37.             myval = getattr(self, '_' + attr)
  38.             if myval is None:
  39.                 return getattr(self.distribution, attr)
  40.             else:
  41.                 return myval
  42.         else:
  43.             raise AttributeError, attr
  44.  
  45.     
  46.     def ensure_finalized(self):
  47.         if not self.finalized:
  48.             self.finalize_options()
  49.         
  50.         self.finalized = 1
  51.  
  52.     
  53.     def initialize_options(self):
  54.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  55.  
  56.     
  57.     def finalize_options(self):
  58.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  59.  
  60.     
  61.     def dump_options(self, header = None, indent = ''):
  62.         longopt_xlate = longopt_xlate
  63.         import distutils.fancy_getopt
  64.         if header is None:
  65.             header = "command options for '%s':" % self.get_command_name()
  66.         
  67.         print indent + header
  68.         indent = indent + '  '
  69.         for option, _, _ in self.user_options:
  70.             option = string.translate(option, longopt_xlate)
  71.             if option[-1] == '=':
  72.                 option = option[:-1]
  73.             
  74.             value = getattr(self, option)
  75.             print indent + '%s = %s' % (option, value)
  76.         
  77.  
  78.     
  79.     def run(self):
  80.         raise RuntimeError, 'abstract method -- subclass %s must override' % self.__class__
  81.  
  82.     
  83.     def announce(self, msg, level = 1):
  84.         log.log(level, msg)
  85.  
  86.     
  87.     def debug_print(self, msg):
  88.         DEBUG = DEBUG
  89.         import distutils.debug
  90.         if DEBUG:
  91.             print msg
  92.             sys.stdout.flush()
  93.         
  94.  
  95.     
  96.     def _ensure_stringlike(self, option, what, default = None):
  97.         val = getattr(self, option)
  98.         if val is None:
  99.             setattr(self, option, default)
  100.             return default
  101.         elif type(val) is not StringType:
  102.             raise DistutilsOptionError, "'%s' must be a %s (got `%s`)" % (option, what, val)
  103.         
  104.         return val
  105.  
  106.     
  107.     def ensure_string(self, option, default = None):
  108.         self._ensure_stringlike(option, 'string', default)
  109.  
  110.     
  111.     def ensure_string_list(self, option):
  112.         val = getattr(self, option)
  113.         if val is None:
  114.             return None
  115.         elif type(val) is StringType:
  116.             setattr(self, option, re.split(',\\s*|\\s+', val))
  117.         elif type(val) is ListType:
  118.             types = map(type, val)
  119.             ok = types == [
  120.                 StringType] * len(val)
  121.         else:
  122.             ok = 0
  123.         if not ok:
  124.             raise DistutilsOptionError, "'%s' must be a list of strings (got %r)" % (option, val)
  125.         
  126.  
  127.     
  128.     def _ensure_tested_string(self, option, tester, what, error_fmt, default = None):
  129.         val = self._ensure_stringlike(option, what, default)
  130.         if val is not None and not tester(val):
  131.             raise DistutilsOptionError, ("error in '%s' option: " + error_fmt) % (option, val)
  132.         
  133.  
  134.     
  135.     def ensure_filename(self, option):
  136.         self._ensure_tested_string(option, os.path.isfile, 'filename', "'%s' does not exist or is not a file")
  137.  
  138.     
  139.     def ensure_dirname(self, option):
  140.         self._ensure_tested_string(option, os.path.isdir, 'directory name', "'%s' does not exist or is not a directory")
  141.  
  142.     
  143.     def get_command_name(self):
  144.         if hasattr(self, 'command_name'):
  145.             return self.command_name
  146.         else:
  147.             return self.__class__.__name__
  148.  
  149.     
  150.     def set_undefined_options(self, src_cmd, *option_pairs):
  151.         src_cmd_obj = self.distribution.get_command_obj(src_cmd)
  152.         src_cmd_obj.ensure_finalized()
  153.         for src_option, dst_option in option_pairs:
  154.             if getattr(self, dst_option) is None:
  155.                 setattr(self, dst_option, getattr(src_cmd_obj, src_option))
  156.                 continue
  157.         
  158.  
  159.     
  160.     def get_finalized_command(self, command, create = 1):
  161.         cmd_obj = self.distribution.get_command_obj(command, create)
  162.         cmd_obj.ensure_finalized()
  163.         return cmd_obj
  164.  
  165.     
  166.     def reinitialize_command(self, command, reinit_subcommands = 0):
  167.         return self.distribution.reinitialize_command(command, reinit_subcommands)
  168.  
  169.     
  170.     def run_command(self, command):
  171.         self.distribution.run_command(command)
  172.  
  173.     
  174.     def get_sub_commands(self):
  175.         commands = []
  176.         for cmd_name, method in self.sub_commands:
  177.             if method is None or method(self):
  178.                 commands.append(cmd_name)
  179.                 continue
  180.         
  181.         return commands
  182.  
  183.     
  184.     def warn(self, msg):
  185.         sys.stderr.write('warning: %s: %s\n' % (self.get_command_name(), msg))
  186.  
  187.     
  188.     def execute(self, func, args, msg = None, level = 1):
  189.         util.execute(func, args, msg, dry_run = self.dry_run)
  190.  
  191.     
  192.     def mkpath(self, name, mode = 511):
  193.         dir_util.mkpath(name, mode, dry_run = self.dry_run)
  194.  
  195.     
  196.     def copy_file(self, infile, outfile, preserve_mode = 1, preserve_times = 1, link = None, level = 1):
  197.         return file_util.copy_file(infile, outfile, preserve_mode, preserve_times, not (self.force), link, dry_run = self.dry_run)
  198.  
  199.     
  200.     def copy_tree(self, infile, outfile, preserve_mode = 1, preserve_times = 1, preserve_symlinks = 0, level = 1):
  201.         return dir_util.copy_tree(infile, outfile, preserve_mode, preserve_times, preserve_symlinks, not (self.force), dry_run = self.dry_run)
  202.  
  203.     
  204.     def move_file(self, src, dst, level = 1):
  205.         return file_util.move_file(src, dst, dry_run = self.dry_run)
  206.  
  207.     
  208.     def spawn(self, cmd, search_path = 1, level = 1):
  209.         spawn = spawn
  210.         import distutils.spawn
  211.         spawn(cmd, search_path, dry_run = self.dry_run)
  212.  
  213.     
  214.     def make_archive(self, base_name, format, root_dir = None, base_dir = None):
  215.         return archive_util.make_archive(base_name, format, root_dir, base_dir, dry_run = self.dry_run)
  216.  
  217.     
  218.     def make_file(self, infiles, outfile, func, args, exec_msg = None, skip_msg = None, level = 1):
  219.         if exec_msg is None:
  220.             exec_msg = 'generating %s from %s' % (outfile, string.join(infiles, ', '))
  221.         
  222.         if skip_msg is None:
  223.             skip_msg = 'skipping %s (inputs unchanged)' % outfile
  224.         
  225.         if type(infiles) is StringType:
  226.             infiles = (infiles,)
  227.         elif type(infiles) not in (ListType, TupleType):
  228.             raise TypeError, "'infiles' must be a string, or a list or tuple of strings"
  229.         
  230.         if self.force or dep_util.newer_group(infiles, outfile):
  231.             self.execute(func, args, exec_msg, level)
  232.         else:
  233.             log.debug(skip_msg)
  234.  
  235.  
  236.  
  237. class install_misc(Command):
  238.     user_options = [
  239.         ('install-dir=', 'd', 'directory to install the files to')]
  240.     
  241.     def initialize_options(self):
  242.         self.install_dir = None
  243.         self.outfiles = []
  244.  
  245.     
  246.     def _install_dir_from(self, dirname):
  247.         self.set_undefined_options('install', (dirname, 'install_dir'))
  248.  
  249.     
  250.     def _copy_files(self, filelist):
  251.         self.outfiles = []
  252.         if not filelist:
  253.             return None
  254.         
  255.         self.mkpath(self.install_dir)
  256.         for f in filelist:
  257.             self.copy_file(f, self.install_dir)
  258.             self.outfiles.append(os.path.join(self.install_dir, f))
  259.         
  260.  
  261.     
  262.     def get_outputs(self):
  263.         return self.outfiles
  264.  
  265.  
  266. if __name__ == '__main__':
  267.     print 'ok'
  268.  
  269.